\chapter{Sitzungsprotokolle}\label{sec:sitzungsprotokolle}
Nachfolgend sind die Sitzungsprotokolle und ihr Inhalt aufgelistet. Es handelt sich dabei nur um stichwortartige Aufzählungen der wichtigsten Aussagen und getroffenen Entscheidungen. 
Es ist anzumerken, dass nur von den grösseren Sitzungen Sitzungsprotokolle in schriftlicher Form existieren. Von einigen kleinen Sitzungen mit Vertretern der Firma SCS oder Herrn Thaler sind keine Unterlagen vorhanden. Der Email-Verkehr wurde ebenfalls nicht beigefügt.
\section{Kick-Off Meeting mit SCS}\label{subsec:kickoff}
\textbf{Anwesende Personen}
\begin{itemize}
\item Samuel Zahnd
\item Reto Bättig
\item David Stadelmann
\item Markus Thaler
\item Mischael Schill
\item Daniel Kummer
\item Sebastian Kummer
\end{itemize}

\textbf{Allgemein}
\begin{itemize}
\item Bilder über Ethernet schicken
\item Einfache Algorithmen implementieren zum testen
\item Essenzielle Funktionen
\begin{itemize} 
\item getImage
\item getInput/setOutput
\item Konfiguration
\item Triggerung intern/extern
\item openCV-angelehnter Syntax?
\item saveBuffer/loadBuffer
\end{itemize}
\item einfache Cross-Compiling und Deployment
\item IDE
\begin{itemize}
\item Plattform-unabhängig
\item One-Button-Deployment
\item Senden der Software über Ethernet
\item Testen des BV Algorithmus
\item Debugging
\item Simulieren?
\end{itemize}
\item Implementation und Test
\item Tutorial zur Benutzung
\end{itemize}

\textbf{Unklarheiten}
\begin{itemize}
\item Mehrere Trigger
\item Mehrere Programme
\item Was für Konfigurationen, wann: Systemstart, Programmstart, Rekonfiguration
\end{itemize}

\textbf{Weitere Möglichkeiten/Schritte}
\begin{itemize}
\item Optimierung Capture Driver
\item Signalprozessor-Spezifische Funktionen
\end{itemize}

\section{Sitzung mit SCS Datum: 11.10.07}\label{subsec:sitzung111007}
\textbf{Anwesende Personen}
\begin{itemize}
\item Samuel Zahnd
\item Reto Bättig
\item Daniel Kummer
\item Sebastian Kummer
\end{itemize}

\textbf{Zu priorisierende Lösung}
\begin{enumerate}
\item Variante: Standalone Kompilierung
\item Variante: One-Button-Cross-Compiling mit automatischem Laden aufs Zielsystem
\end{enumerate}

\textbf{Wichtigste ToDos}
\begin{itemize}
\item Informationen über API und Register zusammentragen und Dokument erstellen
\end{itemize}

\textbf{Nächste Schritte}
\begin{itemize}
\item Anwendungen / Informationen zusammentragen
\begin{itemize}
\item Auf Host laufen
\item Auf Device laufen
\item Matlab...
\item Kommunikation
\end{itemize}
\item IDE auswählen und entscheiden
\begin{itemize}
\item Eclipse oder Alternativen
\item Als erstes auf make und make install fixieren
\end{itemize}
\item Kommunikation interessiert im Moment nicht
\item Funktionen definieren, welche Funktionen überladen, welche nicht
\item Alle Dokumente zusammentragen, alles Protokollieren
\item CVS anschauen
\end{itemize}


\textbf{Allgemein}
\begin{itemize}
\item Toolchain anpassen und neu builden
\item PC: Mit Funktionen auf Files zugreifen ;  anderes API
\item statisches linken ;  überprüfen das glibc nicht dabei ist
\item uclibc einsetzen
\item Kamera-remote über GenICam
\item gleiche Funktionsheader für PC und Kamera ;  Parameter werden nicht beachtet
\item Code-Dokumentation mit doxygen
\item API muss ohne Zielsystem funktionieren
\item Programm läuft unter uClinux im Userspace
\item API muss Hardware abstrahieren: Kamera, Flash etc... es müssen auch verschiedene Zielsysteme unterstützen (wählen beim Kompilieren)
\item Parameter generisch halten ;  Config in XML oder anderes Format
\item XML von GenICam wird zu Config umgewandelt (Eher Schill betreffend)
\item malloc ;  persistent, non-persistent (über Flashdriver)
\end{itemize}

\textbf{Ausblick (mögliche weitere Schritte)}
\begin{itemize}
\item dSpace: Simulink Beispiel für Hardware-In-The-Loop, lässt sich crosscompilen auf C
\item Alles offen lassen für Integration in Matlab/Simulink
\end{itemize}

\section{Sitzung mit SCS Datum: 28.09.07}\label{subsec:sitzung280907}

\textbf{Allgemein}
\begin{itemize}
\item System zur einfachen Implementation von Algorithmen
\item Wunsch: Alle Einstellungen auf Plattform automatisch Testen und einfaches Deployment auf Zielsystem
\item Ideen
\begin{itemize}
\item Open Source
\item Auf Kamera ein Grund-Framework ;  Settings, Bilder schicken, holen usw
\item Wenns auf dem PC läuft, läufts auch auf dem DSP
\item Debuggen
\item Var1: Simulieren ;  oder direkt von Kamera über Ethernet (RPC?)
\item Var2: Bilder aufnehmen und auf HDD speichern
\item Protokoll GigEVision benutzen
\end{itemize}
\item Funktionen definieren mit Schill (Schnittstelle)
\item Bestehende Schnittstellen wenn möglich verwenden
\item Entwürfe reviewen
\item API
\item Diverse Ideen zur API Implementation
\item Wichtig: Brauchbar!
\item 1. Cross-Compiling vereinfachen
\item 2. Hardware-in-the-loop ;  Direkt Kamera ansprechen
\item uCLinux läuft im Ramdisk
\item Bilder über Ethernet schicken
\item Typischerweise 2-D Bilder
\item Demo
\item Capture Driver rewrite:
\begin{itemize}
\item Idee: 3 Buffer ständig füllen mit Bildern, immer den letzten Buffer als Bildquelle verwenden
\item Bilder über DMA im SDRAM ;  blockiert zu schnelles holen Ramzugriffe?
\end{itemize}
\end{itemize}

\textbf{Mail ETH Student}
fabian.brugger@gmail.com

\textbf{Initialisierung der Kamera: (einige Werte)}
\begin{itemize}
\item Belichtungszeit
\item Gain
\item Auto Gain Switches
\item Triggerung (Intern/Extern)
\end{itemize}

\section{Sitzung mit SCS Datum: 25.10.07}\label{subsec:sitzung251007}
\begin{itemize}
\item Debugging ;  Ethernet/Seriell
\begin{itemize}
\item wie aufsetzen / konfigurieren
\item was für Vor- Nachteile
\end{itemize}
\item CVS Snapshot builden
\item Externe Anschlüsse ;  Interrupt-Support?
\item Vielleicht interner Trigger in Treiber einbauen
\item Treiber "tunen" ;  Treiber über anderen ioctl Befehl aufsetzen + ein weiterer Befehl "hole letztes Bild"
\item Wenn API definiert ist ;  Treiber umbauen
\begin{itemize}
\item Betriebsarten:
\begin{itemize}
\item continuous
\item trigger
\item neuer ioctl Befehl
\end{itemize}
\end{itemize}
\item API + BV Funktionsbibliothek
\item persitent malloc? ;  eher Flash File System!
\item Algorithmus ;  Stapel von Zeitungen beobachten und vergleichen mit Referenzbildern
\item captureFrame auf Hostsystem: Dateinamen nummeriert ;  immer anderes Bild lesen (oder Dateinamen angeben)
\item io auf Hostsystem: Timestamp loggen in Datei ;  Was lief an den GPIO Pins? Welcher Pin bei welchem Frame?
\item externer Trigger im Moment sein lassen
\end{itemize}

\textbf{Ziele}
\begin{enumerate}
\item API auf Zielsystem (1.1 Debugging auf Zielsystem)
\begin{enumerate}
\item holen (Software trigger)
\item bearbeiten
\item io-pins setzen
\item konfigurieren
\end{enumerate}
\item API auf Host bringen
\begin{enumerate}
\item Pic von Files
\item Loggen in Datei ;  welches Frame, welcher Pin
\end{enumerate}
\end{enumerate}
